One Pile Nim with Arbitrary Move Function

This paper solves a class of combinatorial games consisting of one-pile counter pickup games for which the maximum number of counters that can be removed on each successive move equals f(t), where t is the previous move size and f is an arbitrary function. The purpose of this paper is to solve a class of combinatorial games consisting of one-pile counter pickup games for which the maximum number of counters that can be removed on each successive move changes during the play of the game. Two players alternate removing a positive number of counters from the pile. An ordered pair (N, x) of positive integers is called a position. The number N represents the size of the pile of counters, and x represents the greatest number of counters that can be removed on the next move. A function f : Z → Z is given which determines the maximum size of the next move in terms of the current move size. Thus a move in a game is an ordered pair of positions (N, x) 7→ (N − k, f(k)), where 1 ≤ k ≤ min(N, x). The game ends when there are no counters left, and the winner is the last player to move in a game. In this paper we will consider f : Z → Z to be completely arbitrary. That is, we place no restrictions on f . This paper extends a previous paper by the authors [2], which in turn extended two other papers, [1] and [3]. The paper by Epp and Ferguson [1] assumed f is non-decreasing, and the paper [3] assumed f is non-decreasing and f(n) ≥ n. Our previous paper [2] assumed more restrictive conditions on f including as a special case all f : Z → Z that satisfy f(n + 1) − f(n) ≥ −1. the electronic journal of combinatorics 10 (2003), #N7 1 The main theorem of this paper will also allow the information concerning the strategy of a game to be stored very efficiently. We now proceed to develop the theory. Generalized Bases: An infinite strictly increasing sequence B = (b0 = 1, b1, b2, · · · ) of positive integers is called an infinite g-base if for each k ≥ 0, bk+1 ≤ 2bk. This ‘slow growth’ of B’s members guarantees lemma 1. Finite g-bases. A finite strictly increasing sequence B = (b0 = 1, b1, b2, · · · , bt) of positive integers is called a finite g-base if for each 0 ≤ k < t, bk+1 ≤ 2bk. Lemma 1. Let B be an infinite g-base. Then each positive integer N can be represented as N = bi1 + bi2 + · · ·+ bit where bi1 < bi2 < · · · < bit and each bij belongs to B. Proof. The proof is given by the following recursive algorithm. Note that b0 = 1 ∈ B. Suppose all integers 1, 2, 3, · · · , m−1 have been represented as a sum of distinct members of B by the algorithm. Suppose bk ≤ m < bk+1. Then m = (m − bk) + bk. Now m − bk < bk, for otherwise, 2bk ≤ m. Since m < bk+1, we have 2bk < bk+1, which contradicts the definition of a g-base. Since m − bk is less than m, it follows that m − bk has been represented by the algorithm as a sum of distinct members of B that are less than bk. Thus we may assume that m− bk = bi1 + bi2 + · · ·+ bit−1 where bi1 < bi2 < · · · < bit−1 and each bij belongs to B. Then m = bi1 +bi2 + · · ·+bit where bit = bk, bi1 < bi2 < · · · < bit and each bij belongs to B. Lemma 2. Let B = (b0 = 1, b1, b2 · · · bt) be a finite g-base. For any positive integer N , let θ ≥ 0 be the unique integer such that 0 ≤ N − θbt < bt. Then the same algorithm used in the proof of lemma 1 can be used to uniquely represent N = bi1 + bi2 + · · · + bik + θbt where bi1 < bi2 < · · · < bik < bt and each bij belongs to B. In this paper we always use the algorithms used in the proofs of lemmas 1 and 2 to uniquely represent any positive integer N as the sum of distinct members of the g-base that we are dealing, whether this g-base is finite or infinite. Definition 3. Representation of a positive integer. Suppose B = (b0 = 1, b1, b2, · · · ), where b0 < b1 < b2 < · · · , is an infinite g-base. Let N = bi1 + bi2 + · · · + bik , where bi1 < bi2 < · · · < bik , be the representation of a positive integer N that is specified by the algorithm used in the proof of lemma 1. Then we define g(N) = bi1 . Suppose B = (b0 = 1, b1, b2, · · · bt), where b0 < b1 < · · · < bt, is a finite g-base. Let N = bi1 + bi2 + · · ·+ bik + θbt, where bi1 < bi2 < · · · < bik < bt be the representation of N in B that is specified by the algorithm used in lemma 2. Then g(N) = bi1 unless N = θbt in which case g(N) = bt. Generating g-bases: For every function f : Z → Z, we generate a g-base Bf and a function g′ : Bf → Z as follows. Let b0 = 1, g ′(b0) = 1, b1 = 2, g′(b1) = 2. Suppose b0, b1, b2, · · · , bk and g′(b0), g′(b1), g′(b2), · · · , g′(bk), where k ≥ 1, have been generated. Then bk+1 = bk + bi where bi is the smallest member of {b0, b1, · · · , bk} such that g′(bi) = bi and f(bi) ≥ g′(bk) if such a bi exists. If no such bi exists for some k, the g-base Bf is finite. Also, g ′(bk+1) = the electronic journal of combinatorics 10 (2003), #N7 2 min[{bk+1}∪{bk+1 − bk +x : 1 ≤ x < bk and f(bk+1 − bk +x) < g′(g(bk −x))}]. Of course, g(bk −x) is computed using definition 3 with (b0 = 1, b1, b2, · · · , bk), and min S means the smallest member of S. We will explain later why Bf and g ′ are defined this way. Also, we note that since bk+1 = bk + bi and b0 = 1 ≤ bi ≤ bk, it follows that Bf is indeed a g-base. Definition 4. Suppose f : Z → Z generates the g-base Bf and the function g′ : Bf → Z. Then for every N ∈ Z, we define g′(N) = g′(g(N)), where g(N) is computed using Bf . Thus in the definition of g ′(bk+1), we could substitute g′(bk − x) for g′(g(bk − x)). Before we state the main theorem, we need a few more definitions. We recall that for our game, we are given some arbitrary function f : Z → Z. That is, we place no restrictions on f . Also, a position in the game is an ordered pair of positive integers (N, x), and a move is (N, x) 7→ (N − k, f(k)), 1 ≤ k ≤ min(N, x). A position (N, x) is called unsafe if it is unsafe to move to it. Since the player who moves to an unsafe position loses with best play, the player who moves from an unsafe position can always win. Similarly, a position is safe if it is safe to move to it. For each ordered pair (N, x), define F (N, x) = 0 if (N, x) is a safe position, and F (N, x) = 1 if (N, x) is an unsafe position. Note that F (N, x) = 1 when the list F (N −1, f(1)), F (N −2, f(2)), · · · , F (N −x, f(x)) contains at least one 0. Note that F (0, x) = 0 for all x ∈ Z. F (N, x) = 0 when this list contains no 0’s. We imagine that F (1, x), x = 1, 2, · · · , is computed first. Then F (2, x), x = 1, 2, 3, · · · , is computed. Then F (3, x), x = 1, 2, 3, · · · , is computed, etc. Note that F (N, x) = 1 when N ≤ x. Note also that for a fixed N ∈ Z and a variable x ∈ Z, the infinite sequence F (N, x), x = 1, 2, 3, · · · , always consists of a finite string (possibly empty) of consecutive 0’s followed by an infinite string of consecutive 1’s. This is because F (N, x) = 1 when x ≥ N and also once the sequence first switches from 0 to 1 it must retain the value of 1 thereafter. For each N ∈ Z, define g(N) to be the smallest x ∈ Z such that F (N, x) = 1. Of course 1 ≤ g(N) ≤ N . For every N ∈ Z, g(N) is the position of the first 0 in the sequence F (N − 1, f(1)), F (N − 2, f(2)), · · · , F (N − g(N), f(g(N)). This means that F (N − g(N), f(g(N))) = 0, but all preceding members of this sequence have a value of 1. It is obvious that F (N, x) = 0 when x ≤ g(N) − 1 and f(N, x) = 1 when x ≥ g(N). We can now state the main theorem. Main theorem: Suppose we play our game with an arbitrary but fixed move function f : Z → Z. Suppose f generates the g-base Bf and the function g′ : Bf → Z. Then for every N ∈ Z, g(N) = g′(N) where g′(N) is defined in definition 4 using the g-base Bf and the function g ′ : Bf → Z. The main theorem implies that a position (N, x) is unsafe if x ≥ g′(N) and safe if x < g′(N). This means a winning move must be (N, x) → (N − g′(N), f(g′(N))). The reader will note that the theorem is true whether Bf is finite or infinite. In a moment we will write a detailed proof for the case where Bf is infinite. The proof of the finite case, which involves a slight modification of the infinite case, is left to the reader. Before we begin the proof, we would like to point out that for an enormous number of functions f it is very easy to compute Bf and g ′. For example, if f is non-decreasing or if f satisfies f(n + 1) − f(n) ≥ −1, then g′ : Bf → Z is just the identity function on Bf , and Bf is generated by the following very simple algorithm. b0 = 1, b1 = 2 and if the electronic journal of combinatorics 10 (2003), #N7 3 b0, b1, b2, · · · , bk have been generated, then bk+1 = bk+bi where bi is the smallest member of {b0, bi, · · · bk} such that f(bi) ≥ bk. There are also many other functions f for which Bf and g′ are very easy to compute. However, for many functions f , the best way to compute Bf and g′ is to go ahead and compute g(N) first. Note that g(N), N = 1, 2, 3, · · · , can be computed directly by the following algorithm: g(1) = 1, g(2) = 2. If g(1), g(2), · · · , g(k − 1), k ≥ 3, have been computed, then g(k) is the smallest x ∈ {1, 2, 3, · · · , k} such that f(x) < g(k − x), where we agree that g(0) = ∞. For those functions where g(N) is computed first, it may appear that this paper has no advantages whatsoever since we already know g(N). However, once g(N) is computed, we know that g′ = g, and we can then easily compute Bf . Once we know Bf and g ′ : Bf → Z, we know that Bf and g′ by themselves store the complete strategy of the game. Quite often the members of Bf grow exponentially. In these cases we have an efficient way of storing the strategy of the game. We conjecture that if g is unbounded, then the members of Bt always grow exponentially. At the end of this paper, we give two examples in which Bf , g ′ provide efficient storage. We will also give an example when Bf , g ′ provide inefficient storage. In the first two examples, g is unbounded and in the third, g is bounded. Proof. The main theorem follows easily if we can prove the following statements. We assume Bf is infinite. 1. ∀bi ∈ Bf , g(bi) = g′(bi), 2. ∀N ∈ Z\Bf , g(N) < N, 3. ∀N ∈ Z\Bf , if bi < N < bi+1, then N = bi + (N − bi), where 1 ≤ N − bi < bi, and g(N) = g(N − bi). Of course, 1 ≤ N − bi < bi is obvious since Bf is a g-base. Note: At the end of the proof, we will use property 3 to explain why we defined Bf the way that we did. The main theorem follows because if N = bi1 +bi2 +· · ·+bik , where bi1 < bi2 < · · · < bik , is the representation of N in the infinite g-base Bf that is computed by the algorithm used in the proof of lemma 1, we have the following. g(N) = g((bi1 + · · · + bik−1) + bik) = g((bi1 + · · · + bik−2) + bik−1) = g((bi1 + · · · + bik−3) + bik−2) = · · · = = g(bi1) = g (bi1) = g ′(N), by the definition of g′(N) since g(bi1) = g ′(g(N)). Note that once we have proved statements 1, 2, 3 for all members of {1, 2, 3, · · · , k}, then ∀N ∈ {1, 2, 3, · · ·k}, g(N) = g′(N) will also be true. We prove statements 1, 2, 3 by mathematical induction. First, note that no matter what f is g(1) = g′(1) = 1 and g(2) = g′(2) = 2. Conditions 2, 3 do not apply for integers 1, 2 since {1, 2} ⊆ Bf . the electronic journal of combinatorics 10 (2003), #N7 4 Let us suppose that condition 1 is true for all bi ∈ {b0, b1, b2, · · · , bk}, where k ≥ 1, and conditions 2, 3 are true for all N ∈ {1, 2, 3, 4, · · · , bk}\Bf . We show that conditions 2, 3 are true for all N ∈ {bk +1, bk +2, · · · , bk+1−1}, and condition 1 is true for bi = bk+1. Define bθ(k) by bk+1 = bk + bθ(k), where bθ(k) ∈ {b0, b1, b2, · · · , bk}. In the following argument, we omit the first part when bk+1 − bk = 1. So let us imagine that bk+1 − bk ≥ 2. We will prove that conditions 2, 3 are true for N ∈ {bk + 1, bk + 2, · · · , bk+1 − 1} by proving this sequentially with N starting at N = bk + 1 and ending at N = bk+1 − 1. Note that once we prove condition 3 for any N ∈ {bk+1, · · · , bk+1−1}, condition 2 will follow for this N as well. This is because if N = bk +(N −bk), where 1 ≤ N −bk < bk, and g(N) = g(N − bk), then g(N) = g(N − bk) ≤ N − bk < N . Note that g(N − bk) ≤ N − bk is always true. So let us now prove condition 3 is true for N as N varies sequentially over bk + 1, · · · , bk+1 − 1. Since we are assuming that bk+1 − bk ≥ 2, this means that f(1) < g′(bk) = g(bk) is assumed as well since g′(1) = 1. Therefore, g(bk + 1) = g(1) = 1 is obvious. Therefore, suppose we have proved condition 3 for all N ∈ {bk + 1, bk + 2, · · · , bk + t − 1} where bk + t − 1 ≤ bk+1 − 2. This implies for all N ∈ {1, 2, 3, · · · , bk + t − 1}, g(N) = g′(N). We now prove condition 3 for N = bk + t. This means we know that g(i) = g(bk + i), i = 1, 2, 3, · · · , t − 1 and we wish to prove g(t) = g(bk + t). Recall that g(t) is the smallest positive integer x such that the list (1) F (t − 1, f(1)), F (t − 2, f(2)), · · · , F (t − x, f(x)) contains exactly one 0 (which comes at the end of the list). Also, g(bk + t) is the smallest positive integer x such that the list (2) F (bk + t − 1, f(1)), F (bk + t−2, f(2)), · · · , F (bk + t−x, f(x)) contains exactly one 0 (which comes at the end). Since we are assuming that g(i) = g(bk + i), i = 1, 2, · · · , t−1, we know that the above two lists must be identical as long as 1 ≤ x ≤ t−1. This follows from the definition of g since g(N) tells us that F (N, x) = 0 when 1 ≤ x ≤ g(N) − 1 and f(N, x) = 1 when g(N) ≤ x. Now if t / ∈ {b0 = 1, b1, b2 · · · , bθ(k)−1}, we know from condition 2 that g(t) < t. This tells us that for list (1) the smallest x such that list (1) contains exactly one 0 satisfies 1 ≤ x ≤ t − 1. Therefore, since the two lists (1),(2) are identical when 1 ≤ x ≤ t − 1, this tells us that g(t) = g(bk + t). Next, suppose t ∈ {b0 = 1, b1, b2 · · · , bθ(k)−1}. Of course, g(t) = g′(t) since t < bk+t−1. Now if g(t) = g′(t) < t, the same argument used above holds to show that g(t) = g(bk +t). Now if g(t) = g′(t) = t, we know from the definition of how bk+1 = bk + bθ(k) is generated that f(t) < g′(bk) = g(bk). Since g′(t) = g(t) = t, we know that the first t− 1 members of each of the lists (1), (2) consists of all 1’s since they are identical up this point and g(t) = t. Now in list (1), F (t − t, f(t)) = F (0, f(t)) = 0. Also, in list (2), F (bk + t − t, f(t)) = F (bk, f(t)) = 0 since f(t) < g(bk) = g ′(bk). This tells us that g(t) = g(bk + t) = t when t ∈ {b0, b1, · · · , bθ(k)−1}, and g(t) = g′(t) = t. Of course, g(t) = g(bk +t) is what we wished to show. Finally, we show that g(bk+1) = g ′(bk+1). Recall that bk+1 = bk +bθ(k) where g′(bθ(k)) = g(bθ(k)) = bθ(k) and f(bθ(k)) ≥ g′(bk) = g(bk). We now know that ∀N ∈ {1, 2, 3, 4, · · · , bk+1− 1}, g(N) = g′(N). Also, we know that g(i) = g(bk + i), i = 1, 2, 3, · · · , bθ(k) − 1. Since g(bθ(k)) = bθ(k) we know that all terms in the following sequence are 1’s except the final the electronic journal of combinatorics 10 (2003), #N7 5 term which is 0. (3) F (bθ(k) − 1, f(1)), F (bθ(k) − 2, f(2)), F (bθ(k) − 3, f(3)), · · · , F (1, f(bθ(k) − 1)), F (0, f(bθ(k))) = 0. Now g(bk+1) = g(bk + bθ(k)) is the position of the first 0 in the following sequence where we note that the position of a term F (bk + bθ(k) − i, f(i)) is i. (4) F (bk+bθ(k)−1, f(1)), F (bk+bθ(k)−2, f(2)), · · · , F (bk+1, f(bθ(k)−1)), F (bk, f(bθ(k))), F (bk−1, f(bθ(k)+1)), F (bk−2, f(bθ(k)+2)), · · · , F (1, f(bθ(k)+bk−1)), F (0, f(bθ(k)+bk)) = 0. Since g(bk + i) = g(i), i = 1, 2, · · · , bθ(k) − 1, we know that the first bθ(k) − 1 terms of (4) are 1’s since the first bθ(k) − 1 terms of (3) are 1’s. Now F (bk, f(bθ(k))) = 1 from the definition of g since f(bθ(k)) ≥ g′(bk) = g(bk). Note that the last term in (4) is 0. Recall that for all N ∈ {1, 2, 3, . . . , bk+1 − 1}, g(N) = g′(N). From (4), we see that g(bk+1) is the smallest bθ(k) + x, 1 ≤ x ≤ bk such that F (bk − x, f(bθ(k) +x)) = 0. Since F (bk−bk, f(bθ(k) +bk)) = 0, we see that g(bk+1) is the smaller of bθ(k) +bk = bk+1 and the smallest bθ(k) +x, 1 ≤ x < bk, such that F (bk−x, f(bθ(k) +x)) = 0 if such a bθ(k) + x exists. Now F (bk − x, f(bθ(k) + x)) = 0, when 1 ≤ x < bk, if and only if f(bθ(k) + x) < g(bk − x). Since bθ(k) = bk+1 − bk and since g(bk − x) = g′(bk − x) = g′(g(bk − x)), if we compare the above definition of g(bk+1) with the definition of g′(bk+1) given earlier in this paper, we see that g(bk+1) = g ′(bk+1). Observation: We now explain why we defined Bf the way that we did. Assuming that Bf is infinite, we know from the definition of Bf that bi+1 − bi ≤ bi. Also, from the definition of bi+1, we know that g ′(bi+1 − bi) = bi+1 − bi. Also, from the definition of g′(bi+1) (since x ≥ 1 in the definition), we know that g′(bi+1) > bi+1 − bi = g′(bi+1 − bi). Thus g(bi+1) > g(bi+1 − bi). However, from statement 3 (at the beginning of the proof) we know that for all N satisfying bi < N < bi+1 it is true that g(N) = g(N − bi). This change at bi+1 is precisely why we defined Bf the way that we did. The misère version: To win at the misère version (N, x) of dynamic nim, simply use the theory to win the game (N − 1, x), so that your opponent is forced to take the last counter. The reader may like to figure out the strategy for the following variation. Suppose S ⊆ Z ∪ {0}, and the game is over as soon as N ∈ S, N being the pile size. In this paper S = {0}. A difficult problem is to find (with proof) functions f : Z → Z such that Bf and g′ satisfy the following. {bi : bi ∈ Bf , g′(bi) < bi} is infinite and {bi : bi ∈ Bf , g′(bi) = bi} is infinite. We now give two examples of such functions. In both examples, Bf and g ′ will store the strategy extremely efficiently since the members of Bf grow exponentially. Example 1: Define f(n) = n, n 6= 8, k = 0, 1, 2, 3, · · · , f(8) = 4 · 8. Then Bf = {a · 8 : a, b integers, 1 ≤ a ≤ 7, 0 ≤ b}, and g′(a · 8) = φ(a) · 8, where φ(1) = 1, φ(2) = 2, φ(3) = 3, φ(4) = 4, φ(5) = 2, φ(6) = 2, φ(7) = 3. Noting that g′(a · 8) ≤ 4 · 8, we leave the proof as an exercise for the reader. The proof is by induction in blocks of seven starting with proving that {1, 2, 3, 4, 5, 6, 7} ⊆ Bf and g′(1) = 1, g′(2) = 2, g′(3) = 3, g′(4) = 4, g′(5) = 2, g′(6) = 2, g′(7) = 3. the electronic journal of combinatorics 10 (2003), #N7 6 Example 2: Define f(n) = n, if n is even and f(n) = 4n, if n is odd. Instead of calling Bf = (b0 = 1 < b1 < b2 < · · · ), it is more convenient to call Bf = (a1 = 1 < b1 < c1 < a2 < b2 < c2 < d2 < a3 < b3 < c3 < d3 < · · · < ai < bi < ci < di < · · · ). The first few terms of Bf and the corresponding g′ are computed by the following recursion. First, we define a strictly increasing sequence ∆2, ∆3, . . . recursively as follows: ∆2 = 1, ∆3 = 3 and for all i ≥ 4, ∆i = ∆i−1 + 4∆i−2. Also, define a1 = 1, g′(a1) = 1, b1 = 2, g′(b1) = 2, c1 = 3, g′(c1) = 3, a2 = 4, g′(a2) = 4, b2 = 5, g′(b2) = 2, c2 = 6, g′(c2) = 2, d2 = 7, g ′(d2) = 7. For all i ≥ 3, define ai, g′(ai), bi, g′(bi), ci, g′(ci), di, g′(di) recursively as follows: ai = di−1 + ∆i, g′(ai) = ai, bi = ai + ∆i, g′(bi) = 2∆i, ci = bi + ∆i, g′(ci) = 2∆i, di = ci + ∆i, g ′(di) = di. In the third example, we give an example of a function f such that Bf = Z . If Bf = Z , it is easy to prove that g must be bounded. The reader can show that if either g or f is bounded, then eventually g must become periodic. Example 3: Let f(1) = 4, f(n) = 2, n ≥ 2. Then g(1) = 1, g(2 + 4k) = 2, g(3 + 4k) = 3, g(4 + 4k) = 4, g(5 + 4k) = 2, k = 0, 1, 2, 3, · · · . Also, it is easy to see that Bf = Z . Of course, g′ = g on Bf . Appendix. The functions f, g, g′ and the base Bf described in this paper have a great many properties, a few of which are listed below. Recall that f is given, and it determines the other three. 1. g is periodic on Z if and only if Bf is finite. 2. If f is bounded, there exists a positive integer a such that g is periodic on [a,∞). 3. If g is bounded, then there exists a positive integer a such that g is periodic on [a,∞). 4. Suppose the positive integer a satisfies f(i) < g(a) for all i = 1, 2, 3, . . . , a. Then g is periodic on Z and [1, a] is a period. 5. g is bounded if and only if {bi : bi ∈ Bf , g(bi) = bi} is finite. 6. There exists a positive integer a such that g is periodic on [a,∞) if and only if g is bounded on Bf . Acknowledgement. The authors also acknowledge the referee who made some timely and valuable suggestions. the electronic journal of combinatorics 10 (2003), #N7 7